//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////@

// PK -- Νέος παίκτης
//
// p:	Ο ίδιος ο παίκτης χωρίς ευαίσθητα δεδομένα.
//
// Νέος παίκτης που πρέπει να ενταχθεί στο σκηνικό. Πέρα από την ένταξη του παίκτη στο
// σκηνικό, δεν διαφαίνεται κάποια άλλη ενέργεια που πρέπει να γίνει.

Skiniko.prototype.processKinisiPK = function(kinisi) {
	this.pektisAdd(new Pektis(kinisi.p).pektis2object());
	return this;
}

//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////@

// SN -- Νέα συνεδρία
//
// p:	Το login name του παίκτη της συνεδρίας.
//
// Η συνεδρία έρχεται χωρίς στοιχεία θέσης και ακολουθείται η ίδια διαδικασία που
// ακολουθείται και στον skiser, δηλαδή εντοπίζεται η συνεδρία και εντάσσεται στο
// σκηνικό.

Skiniko.prototype.processKinisiSN = function(kinisi) {
	var pios = kinisi.p, skiniko = this;

	this.
	rebelosRemoveDOM(pios).
	trapeziWalk(function(kodikos, trapezi) {
		trapezi.theatisWalk(function(pektis, theatis) {
			if (pektis == pios) theatis.theatisRemoveDOM();
		});
	}).

	sinedriaAdd(new Sinedria({
		pektis: pios,
	}).entopismos(skiniko)).

	rebelosRefreshDOM(pios).
	epilogiRefreshDOM(pios).
	trapeziWalk(function(kodikos, trapezi) {
		trapezi.thesiWalk(function(thesi, trapezi) {
			var tablo;

			if (trapezi.pektisGet(thesi) != pios) return;
			trapezi.trapeziPektisRefreshDOM(thesi);

			tablo = trapezi.tabloGet();
			if (tablo.isDOM()) tablo.pektisRefreshDOM(thesi);
		});

		trapezi.theatisWalk(function(pektis, theatis) {
			if (pektis == pios) theatis.theatisRefreshDOM(skiniko, trapezi.trapeziTheatisGetDOM());
		});
	});

	return this;
}

//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////@

// NS -- Διαγραφή συνεδρίας
//
// p:	Το login name τού παίκτη της προς διαγραφήν συνεδρίας.
//
// Η συνεδρία διαγράφεται από το σκηνικό και ενημερώνονται τα σχετικά DOM elements,
// κάποια πριν, κάποια μετά τη διαγραφή της συνεδρίας από το σκηνικό.

Skiniko.prototype.processKinisiNS = function(kinisi) {
	var pios = kinisi.p, skiniko = this;

	this.
	rebelosRemoveDOM(pios).

	rebelosDelete(pios).
	sinedriaDelete(pios).
	epilogiRefreshDOM(pios).

	trapeziWalk(function(kodikos, trapezi) {
		trapezi.thesiWalk(function(thesi, trapezi) {
			var tablo;

			if (trapezi.pektisGet(thesi) != pios) return;
			trapezi.trapeziPektisRefreshDOM(thesi);

			tablo = trapezi.tabloGet();
			if (tablo.isDOM()) tablo.pektisRefreshDOM(thesi);
		});

		trapezi.theatisWalk(function(pektis, theatis) {
			if (pektis == pios) theatis.theatisRemoveDOM();
		});
	});

	return this;
}

//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////@

// TR -- Νέο τραπέζι
//
// t:	Κωδικός νέου τραπεζιού.
//
// p:	Login name του δημιουργού.
//
// l:	Κωδικός αυτοπρόσκλησης δημιουργού.

Skiniko.prototype.processKinisiTR = function(kinisi) {
	var
	skiniko = this,
	trapezi, prosklisi, sinedria,
	dimiourgosEgo = kinisi.p.isEgo(),
	tora = globals.toraServer();

	// Δημιουργούμε το νέο τραπέζι με τα στοιχεία τής κίνησης.

	trapezi = new Trapezi({
		kodikos: kinisi.t,
		pektis1: kinisi.p,
		apodoxi1: 'ΟΧΙ',
		apodoxi2: 'ΟΧΙ',
		stisimo: tora,
	});

	// Αν είμαι εγώ ο δημιουργός του τραπεζιού, τότε δημιουργώ την αυτοπρόσκληση
	// με τον κωδικό της που βρίσκεται στην κίνηση και την εντάσσω στο τραπέζι.

	if (dimiourgosEgo) prosklisi = new Prosklisi({
		kodikos: kinisi.l,
		apo: kinisi.p,
		pros: kinisi.p,
		trapezi: kinisi.t,
		epidosi: tora,
	}).prosklisiAdd(trapezi);

	// Εισάγουμε το νεόκοπο τραπέζι (μαζί με την αυτοπρόσκληση) στο σκηνικό.

	this.trapeziAdd(trapezi);

	// Αν ο δημιουργός είναι περιφερόμενος τον διαγράφουμε από τους περιφερομένους,
	// αφού προηγουμένως διαγράψουμε το σχετικό DOM element.

	this.rebelosRemoveDOM(kinisi.p).rebelosDelete(kinisi.p);

	// Αν ο δημιουργός ήταν περιφερόμενος τον εμπλέκουμε ως παίκτη στη θέση 1
	// στο νέο τραπέζι.

	sinedria = this.sinedriaGet(kinisi.p);
	if (sinedria.isRebelos()) sinedria.setPektis(kinisi.t, 1);

	// Εντάσσουμε το νεόκοπο τραπέζι στο DOM.

	trapezi.trapeziRefreshDOM(this.trapeziGetDOM());

	// Εντάσσουμε την αυτοπρόσκληση στο DOM.

	if (dimiourgosEgo) prosklisi.prosklisiRefreshDOM(this);

	// Ενημερώνουμε του control panel.

	this.
	refreshCpanelDOM().
	epilogiRefreshDOM(kinisi.p);

	// Αν πρόκειται για το δικό μας τραπέζι ενημερώνουμε την
	// περιοχή παρτίδας.

	if (this.sinedriaEgoFetch().isTrapezi(kinisi.t)) this.refreshPartidaDOM();

	if (sinedria.isEgo()) client.ixos.plop();
	return this;
}

//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////@

// EX -- Έξοδος παίκτη/θεατή από τραπέζι
//
// p:	Το login name τού παίκτη/θεατή που εξέρχεται από το τραπέζι.

Skiniko.prototype.processKinisiEX = function(kinisi) {
	var pektis = kinisi.p, sinedria, trapezi, thesi;

	sinedria = this.sinedriaGet(pektis);
	if (!sinedria) globals.fatal('ανύπαρκτη συνεδρία κατά την έξοδο του παίκτη ' + pektis);

	trapezi = this.trapeziGet(sinedria.trapeziGet());
	if (!trapezi) globals.fatal('ακαθόριστο τραπέζι κατά την έξοδο του παίκτη ' + pektis);

	thesi = trapezi.thesiPekti(pektis);

	trapezi.
	exodosPekti(pektis).
	theatisRemoveDOM(pektis).
	theatisDelete(pektis);

	sinedria.
	setRebelos().
	entopismos();

	trapezi.
	trapeziEnergoRefreshDOM().
	trapeziPektisRefreshDOM(thesi);

	if (sinedria.isRebelos())
	this.
	rebelosRefreshDOM(pektis).
	sizitisiKafenioSet();

	this.
	trapeziRefreshDOM(sinedria.trapeziGet()).
	refreshPartidaDOM().
	refreshCpanelDOM().
	epilogiRefreshDOM(pektis).
	refreshSizitisiPartidaDOM().
	sizitisiPartidaSet();

	sinedria = this.sinedriaEgoFetch();
	client.ixos.play(sinedria.isRebelos() ? 'blioup.ogg' : 'pop.ogg');

	return this;
}

//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////@

// ET -- Επιλογή τραπεζιού
//
// p:	Το login name τού παίκτη.
//
// t:	Ο κωδικός τραπεζιού επιλογής.
//
// d:	Το array παρτίδων του τραπεζιού.
//
// z:	Το array σχολίων συζήτησης τραπεζιού.

Skiniko.prototype.processKinisiET = function(kinisi) {
	var pektis = kinisi.p, sinedria, trapezi, trapeziPrin, thesi, tablo, i, sinedriaEgo;

	sinedria = this.sinedriaGet(pektis);
	if (!sinedria) return this;

	trapezi = this.trapeziGet(kinisi.t);
	if (!trapezi) return this;

	trapeziPrin = sinedria.trapeziGet();
	if (trapeziPrin == kinisi.t) return this;

	if (kinisi.isProp('d')) {
		for (i in kinisi.d) kinisi.d[i] = new Partida(kinisi.d[i]).partida2object();
		trapezi.partida = kinisi.d;
	}

	if (kinisi.isProp('z')) {
		for (i in kinisi.z) kinisi.z[i] = new Sizitisi(kinisi.z[i]);
		trapezi.sizitisi = kinisi.z;
	}

	this.
	rebelosRemoveDOM(pektis).
	rebelosDelete(pektis);

	trapeziPrin = this.trapeziGet(trapeziPrin);
	if (trapeziPrin)
	trapeziPrin.
	theatisRemoveDOM(pektis).
	theatisDelete(pektis);

	thesi = trapezi.thesiPekti(pektis);
	if (thesi) {
		sinedria.setPektis(kinisi.t, thesi);
		trapezi.trapeziPektisRefreshDOM(thesi);
		tablo = trapezi.tabloGet();
		if (tablo.isDOM()) tablo.pektisRefreshDOM(thesi);
	}
	else {
		thesi = trapezi.protasiThesis(pektis);
		sinedria.setTheatis(kinisi.t, thesi);
		trapezi.theatisAdd(new Theatis({
			pektis: pektis,
			thesi: thesi,
		}).theatisRefreshDOM(this, trapezi.trapeziTheatisGetDOM()));
	}

	trapezi.
	trapeziEnergoRefreshDOM();

	if (trapeziPrin) {
		thesi = trapeziPrin.thesiPekti(pektis);
		trapeziPrin.
		trapeziEnergoRefreshDOM().
		trapeziPektisRefreshDOM(thesi);
		if (thesi) {
			tablo = trapeziPrin.tabloGet();
			if (tablo.isDOM()) tablo.pektisRefreshDOM(thesi);
		}
	}

	this.
	refreshPartidaDOM().
	refreshCpanelDOM().
	refreshSizitisiPartidaDOM().
	sizitisiPartidaSet();

	sinedriaEgo = this.sinedriaEgoFetch();
	if (sinedriaEgo.isTrapezi(kinisi.t)) this.refreshPartidaDOM();
	else if (trapeziPrin && sinedriaEgo.isTrapezi(trapeziPrin.kodikosGet())) this.refreshPartidaDOM();

	if (sinedria.isEgo()) client.ixos.tak();
	return this;
}

//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////@

// PT -- Εναλλαγή παίκτη/θεατή
//
// p:	Το login name τού παίκτη που αλλάζει ρόλο.

Skiniko.prototype.processKinisiPT = function(kinisi) {
	var pektis = kinisi.p, sinedria, trapezi, thesi, theatis;

	sinedria = this.sinedriaGet(pektis);
	if (!sinedria) return this;

	trapezi = this.trapeziGet(sinedria.trapeziGet());
	if (!trapezi) return this;

	thesi = sinedria.thesiGet();
	if (!thesi) return this;

	theatis = trapezi.theatisGet(pektis);
	if (theatis && trapezi.pektisGet(thesi)) return this;

	sinedria.pektisTheatis();

	trapezi.trapeziPektisRefreshDOM(thesi);
	if (theatis) theatis.theatisRemoveDOM();

	theatis = trapezi.theatisGet(pektis);
	if (theatis)
	theatis.
	theatisRefreshDOM(this, trapezi.trapeziTheatisGetDOM()).
	thesiFlashDOM();

	this.
	refreshCpanelDOM().
	epilogiRefreshDOM(pektis);
	if (this.sinedriaEgoFetch().isTrapezi(trapezi.kodikosGet())) this.refreshPartidaDOM();

	if (sinedria.isEgo()) client.ixos.tak();
	return this;
}

//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////@

// AH -- Αλλαγή θέσης
//
// p:	Το login name τού παίκτη που αλλάζει θέση.

Skiniko.prototype.processKinisiAH = function(kinisi) {
	var sinedria, pektis = kinisi.p, thesiPrin, thesiMeta, theatis;

	sinedria = this.sinedriaGet(pektis);
	if (!sinedria) return this;

	trapezi = this.trapeziGet(sinedria.trapeziGet());
	if (!trapezi) return this;

	thesiPrin = sinedria.thesiGet();
	if (!thesiPrin) return this;

	if (sinedria.isTheatis()) {
		thesiMeta = thesiPrin + 1;
		if (thesiMeta > geister.thesiMax) thesiMeta = 1;
		theatis = trapezi.theatisGet(pektis);
		theatis.thesiSet(thesiMeta).theatisRefreshDOM(this).thesiFlashDOM();
		sinedria.thesiSet(thesiMeta);
	}
	else {
		sinedria.thesiRoloi();
		thesiMeta = sinedria.thesiGet();
		trapezi.
		trapeziPektisRefreshDOM(thesiPrin).
		trapeziPektisRefreshDOM(thesiMeta);
	}

	this.refreshCpanelDOM();
	if (this.sinedriaEgoFetch().isTrapezi(trapezi.kodikosGet())) this.refreshPartidaDOM();

	if (sinedria.isEgo()) client.ixos.tak();
	return this;
}

//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////@

// AX -- Αποδοχή όρων παρτίδας
//
// p:	Το login name τού παίκτη που αποδέχεται τους όρους της παρτίδας.

Skiniko.prototype.processKinisiAX = function(kinisi) {
	var sinedria, trapezi, thesi, tablo;

	sinedria = this.sinedriaGet(kinisi.p);
	if (!sinedria) return this;

	trapezi = this.trapeziGet(sinedria.trapeziGet());
	if (!trapezi) return this;

	if (sinedria.oxiPektis()) return this;
	thesi = sinedria.thesiGet();
	if (!thesi) return this;

	trapezi.apodoxiSet('ΝΑΙ', thesi).trapeziPektisRefreshDOM(thesi);
	if (trapezi.apodoxes() == geister.thesiMax) {
		tablo = trapezi.tabloGet();
		if (tablo.isFasi('ΣΤΗΣΙΜΟ')) tablo.fasiSet('ΠΑΙΧΝΙΔΙ');
	}

	this.refreshCpanelDOM();
	if (this.sinedriaEgoFetch().isTrapezi(trapezi.kodikosGet())) this.refreshPartidaDOM();

	if (sinedria.isEgo()) client.ixos.tak();
	return this;
}

//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////@

// XA -- Επαναδιαπραγμάτευση όρων παρτίδας
//
// p:	Το login name τού παίκτη που αιτείται επαναδιαπραγμάτευση των όρων της παρτίδας.

Skiniko.prototype.processKinisiXA = function(kinisi) {
	var sinedria, trapezi, thesi;

	sinedria = this.sinedriaGet(kinisi.p);
	if (!sinedria) return this;

	trapezi = this.trapeziGet(sinedria.trapeziGet());
	if (!trapezi) return this;

	if (sinedria.oxiPektis()) return this;
	thesi = sinedria.thesiGet();
	if (!thesi) return this;

	trapezi.
	apodoxiSet('ΟΧΙ', thesi).
	trapeziPektisRefreshDOM(thesi);

	this.refreshCpanelDOM();
	if (this.sinedriaEgoFetch().isTrapezi(trapezi.kodikosGet())) this.refreshPartidaDOM();

	if (sinedria.isEgo()) client.ixos.pop();
	return this;
}

//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////@

// PL -- Νέα πρόσκληση
//
// l:	Κωδικός πρόσκλησης.
//
// t:	Κωδικός τραπεζιού.
//
// a:	Login name οικοδεσπότη.
//
// p:	Login name προσκεκλημένου.

Skiniko.prototype.processKinisiPL = function(kinisi) {
	var prosklisi, trapezi;

	prosklisi = new Prosklisi({
		kodikos: kinisi.l,
		trapezi: kinisi.t,
		apo: kinisi.a,
		pros: kinisi.p,
		epidosi: globals.toraServer(),
	});

	trapezi = this.trapeziGet(kinisi.t);
	if (!trapezi) globals.fatal('Ανύπαρκτο τραπέζι προσκλήσεως');

	trapezi.
	prosklisiAdd(prosklisi.prosklisiRefreshDOM(this)).
	trapeziDataRefreshDOM();
	client.ixos.play(prosklisi.ikodespotisEgo() ? 'ding.ogg' : 'sfirigma.ogg');

	this.refreshCpanelDOM();

	return this;
}

//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////@

// DL -- Διαγραφή πρόσκλησης
//
// t:	Κωδικός τραπεζιού.
//
// l:	Κωδικός πρόσκλησης.
//
// a:	Login name οικοδεσπότη (δεν χρησιμοποιείται).
//
// p:	Login name προσκεκλημένου.

Skiniko.prototype.processKinisiDL = function(kinisi) {
	var trapezi, prosklisi;

	trapezi = this.trapeziGet(kinisi.t);
	if (!trapezi) return this;

	prosklisi = trapezi.prosklisiGet(kinisi.l);
	if (!prosklisi) return this;

	prosklisi.
	prosklisiRemoveDOM();

	trapezi.
	prosklisiDelete(kinisi.l).
	trapeziDataRefreshDOM();
	client.ixos.blioup();

	this.refreshCpanelDOM();

	return this;
}

//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////@

// AL -- Αποδοχή πρόσκλησης
//
// p:	Login name προσκεκλημένου.
//
// t:	Κωδικός τραπεζιού.
//
// l:	Κωδικός πρόσκλησης.

Skiniko.prototype.processKinisiAL = function(kinisi) {
	var sinedriaPrin, trapeziPrin, pektis, sinedria, trapezi, thesi;

	trapezi = this.trapeziGet(kinisi.t);
	if (!trapezi) return this;

	pektis = kinisi.p;
	sinedria = this.sinedriaGet(pektis);
	if (!sinedria) return this;

	sinedriaPrin = new Sinedria(sinedria);
	trapeziPrin = this.trapeziGet(sinedria.trapeziGet());

	//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////@
	// Εξετάζουμε την περίπτωση κατά την οποία ο παίκτης βρίσκεται ήδη στο τραπέζι.

	if (trapeziPrin && (trapeziPrin.kodikosGet() == kinisi.t)) {
		// Εάν ο παίκτης ήταν ήδη παίκτης στο τραπέζι, τότε δεν χρειάζεται να γίνει
		// καμία περαιτέρω ενέργεια.

		if (sinedria.isPektis()) return this;

		// Ο παίκτης είναι θεατής στο τραπέζι, οπότε επιχειρούμε να τον καταστήσουμε
		// παίκτη, ει δυνατόν στη θέση που παρακολουθεί.

		thesi = sinedria.thesiGet();

		// Αν η θέση θέασης είναι κατειλημμένη, βρίσκουμε μια κενή θέση.

		if (trapezi.pektisGet(thesi)) thesi = trapezi.keniThesi();

		// Αν δεν βρέθηκε κενή θέση, έχουμε πρόβλημα.

		if (!thesi) return this;

		// Βρέθηκε κενή θέση και ο παίκτης θα τοποθετηθεί ως παίκτης σ' αυτή τη θέση.

		return this.processKinisiALpektis(pektis, sinedria, trapezi, thesi, sinedriaPrin, trapeziPrin);
	}

	// Ο παίκτης δεν βρισκόταν ήδη στο τραπέζι της πρόσκλησης, επομένως ήταν περιφερόμενος,
	// ή βρισκόταν σε άλλο τραπέζι. Εξετάζουμε, λοιπόν, αν ο παίκτης ήδη κατέχει θέση ως
	// παίκτης στο τραπέζι της πρόσκλησης.

	thesi = trapezi.thesiPekti(pektis);
	if (thesi) return this.processKinisiALpektis(pektis, sinedria, trapezi, thesi, sinedriaPrin, trapeziPrin);

	//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////@
	// Ο παίκτης είναι περιφερόμενος, ή βρίσκεται σε άλλο τραπέζι, πάντως δεν βρίσκεται
	// στο τραπέζι τής πρόσκλησης.

	// Ο παίκτης δεν κατέχει ήδη θέση ως παίκτης στο τραπέζι της πρόσκλησης. Ελέγχουμε, λοιπόν,
	// τυχόν προηγούμενο πέρασμα τού παίκτη από το τραπέζι και βρίσκουμε τη θέση που κατείχε τότε,
	// αλλιώς προτείνουμε την πρώτη θέση.

	thesi = trapezi.protasiThesis(pektis);

	// Αν η προτεινόμενη θέση είναι κατειλημμένη, βρίσκουμε μια κενή θέση.

	if (trapezi.pektisGet(thesi)) thesi = trapezi.keniThesi();

	// Αν βρέθηκε κενή θέση, ο παίκτης θα τοποθετηθεί ως παίκτης σ' αυτή τη θέση.

	if (thesi) return this.
	processKinisiALpektis(pektis, sinedria, trapezi, thesi, sinedriaPrin, trapeziPrin).
	epilogiRefreshDOM(pektis);

	// Δεν βρέθηκε κενή θέση, επομένως ο παίκτης θα τοποθετηθεί ως θεατής στην πιο κατάλληλη γι' αυτόν θέση.

	thesi = trapezi.protasiThesis(pektis);
	return this.processKinisiALtheatis(pektis, sinedria, trapezi, thesi, sinedriaPrin, trapeziPrin);
}

Skiniko.prototype.processKinisiALtheatis = function(pektis, sinedria, trapezi, thesi, sinedriaPrin, trapeziPrin) {
	this.processKinisiALprinCleanup(pektis, trapeziPrin);
	sinedria.setTheatis(trapezi.kodikosGet(), thesi);
	trapezi.theatisAdd(new Theatis({
		pektis: pektis,
		thesi: thesi,
	}).theatisRefreshDOM(this, trapezi.trapeziTheatisGetDOM()));
	if (sinedriaPrin.isPektis()) trapeziPrin.trapeziPektisRefreshDOM(sinedriaPrin.thesiGet());
	return this.processKinisiALtelos(sinedria, sinedriaPrin, trapezi, trapeziPrin);
}

Skiniko.prototype.processKinisiALpektis = function(pektis, sinedria, trapezi, thesi, sinedriaPrin, trapeziPrin) {
	this.processKinisiALprinCleanup(pektis, trapeziPrin);
	sinedria.setPektis(trapezi.kodikosGet(), thesi);
	trapezi.pektisSet(pektis, thesi).trapeziPektisRefreshDOM(thesi);
	return this.processKinisiALtelos(sinedria, sinedriaPrin, trapezi, trapeziPrin);
}

Skiniko.prototype.processKinisiALprinCleanup = function(pektis, trapeziPrin) {
	this.rebelosRemoveDOM(pektis).rebelosDelete(pektis);
	if (trapeziPrin) trapeziPrin.theatisRemoveDOM(pektis).theatisDelete(pektis);
	return this;
}

Skiniko.prototype.processKinisiALtelos = function(sinedria, sinedriaPrin, trapezi, trapeziPrin) {
	if (sinedriaPrin.isPektis()) trapeziPrin.trapeziPektisRefreshDOM(sinedriaPrin.thesiGet());
	if (trapeziPrin) trapeziPrin.trapeziEnergoRefreshDOM();
	trapezi.trapeziEnergoRefreshDOM();
	if (sinedria.isEgo()) client.ixos.play(sinedria.isTheatis() ? 'tik.ogg' : 'tak.ogg');

	this.refreshCpanelDOM().refreshSizitisiPartidaDOM();
	if (this.sinedriaEgoFetch().isTrapezi(trapezi.kodikosGet()))
		this.refreshPartidaDOM().sizitisiPartidaSet();
	return this;
}

//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////@

// EG -- Ενέργεια.
//
// e:	Κωδικός ενέργειας.
//
// t:	Κωδικός τραπεζιού.
//
// p:	Θέση παίκτη ενέργειας.
//
// i:	Είδος ενέργειας.
//
// d:	Δεδομένα ενέργειας.

Skiniko.prototype.processKinisiEG = function(kinisi) {
	var trapezi, partida, tablo, pektis, process, energia, nikitis, animation;;

	trapezi = this.trapeziGet(kinisi.t);
	if (!trapezi) globals.fatal(' ανύπαρκτο τραπέζι');

	partida = trapezi.partidaGet();
	if (!partida) globals.fatal('απροσδιόριστη παρτίδα');

	tablo = trapezi.tabloGet();
	if (!tablo) globals.fatal('απροσδιόριστο ταμπλό τραπεζιού');

	process = 'processEnergia' + kinisi.i;
	if (!tablo[process]) globals.fatal('απρόβλεπτο είδος ενέργειας');

	energia = new Energia({
		kodikos: kinisi.e,
		partida: partida.kodikosGet(),
		pektis: kinisi.p,
		idos: kinisi.i,
		data: kinisi.d,
	});

	// TODO
	// Σ' αυτό το σημείο πρέπει να γίνει διαχωρισμός μεταξύ τπυ παίκτη που προκαλεί
	// την ενέργεια και όλων των υπολοίπων. Πράγματι, ο ενεργών παίκτης πρέπει να
	// δει την ενέργεια πιθανόν απευθείας μετά την εφαρμογή της ενέργειας, ενώ οι
	// υπόλοιποι θα πρέπει να δουν την εφαρμογή με animation μετά το τέλος τού
	// οποίου θα πρέπει να επανασχηματιστεί το ταμπλό.

	tablo[process].call(tablo, energia);
	partida.energiaAdd(energia);

	nikitis = tablo.nikitisGet();
	if (nikitis) partida.telosSet(nikitis);

	trapezi.trapeziRefreshDOM();
	this.refreshCpanelDOM();
	if (this.sinedriaEgoFetch().alloTrapezi(kinisi.t)) return this;

	switch (kinisi.i) {
	case 'ΕΞΟΔΟΣ':
		animation = true;
		break;
	default:
		if (tablo.nikitisGet()) animation = true;
		else animation = (trapezi.pektisEgo() != kinisi.p);
		break;
	}

	this.refreshPartidaDOM(animation);
	return this;
}

//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////@

// NP -- Νέα παρτίδα.
//
// k:	Κωδικός παρτίδας.
//
// t:	Κωδικός τραπεζιού.
//
// p:	Ποιός παίζει πρώτος.

Skiniko.prototype.processKinisiNP = function(kinisi) {
	var trapezi, partida, tablo;

	trapezi = this.trapeziFetch(kinisi.t);
	partida = new Partida({
		kodikos: kinisi.k,
		trapezi: kinisi.t,
		protos: kinisi.p,
		enarxi: globals.toraServer(),
	});

	trapezi.
	partidaAdd(partida).
	apodoxiSet('ΟΧΙ');

	this.refreshTrapeziDOM().refreshCpanelDOM();

	if (this.sinedriaEgoFetch().isTrapezi(kinisi.t)) {
		trapezi.tabloGet().replay();
		this.refreshPartidaDOM();
	}

	return this;
}

//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////@

// SZ -- Νέα παρτίδα.
//
// k:	Κωδικός σχολίου.
//
// p:	Ποιός παίζει πρώτος.
//
// s:	Σχόλιο.

Skiniko.prototype.processKinisiSZ = function(kinisi) {
	var sizitisi, trapezi;

	sizitisi = new Sizitisi({
		kodikos: kinisi.k,
		pektis: kinisi.p,
		sxolio: kinisi.s,
		pote: globals.toraServer(),
	});

	if (kinisi.hasOwnProperty('t')) {
		trapezi = this.trapeziGet(kinisi.t);
		if (!trapezi) return this;
		if (this.sizitisiTrapezi != kinisi.t) return this;
		trapezi.sizitisiAdd(sizitisi);
		sizitisi.sizitisiRefreshDOM(this, this.sizitisiPartidaDOM);
	}
	else {
		this.sizitisiAdd(sizitisi);
		sizitisi.sizitisiRefreshDOM(this, this.sizitisiKafenioDOM);
	}

	this.sizitisiDOM.scrollKato();
	return this;
}

//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////@

// RESET -- Reset

Skiniko.prototype.processKinisiRESET = function(kinisi) {
	this.feredata(true, 500);
	return this;
}
